/* eslint-disable no-restricted-syntax */
/* global WeakRef, gc */

import QUnit from 'qunit';
import Application from '@ember/application';
import Engine from '@ember/engine';
import * as ApplicationInstanceModule from '@ember/application/instance';

const HAS_GC = typeof gc === 'function';

let OWNER_REFS = [];

async function fullyGC() {
  await gc({ type: 'major', execution: 'async' });
  await gc({ type: 'major', execution: 'async' });
  await gc({ type: 'major', execution: 'async' });
}

async function checkForRetainedOwners() {
  if (!HAS_GC) {
    throw new Error(
      "You're running Owner leak detection but GC is not enabled!"
    );
  }

  await fullyGC();

  const testNameToRetainedOwner = new Map();

  for (let i = 0; i < OWNER_REFS.length; i++) {
    const [ownerRef, testName] = OWNER_REFS[i];
    const owner = ownerRef.deref();
    if (owner !== undefined) {
      let owners = testNameToRetainedOwner.get(testName);
      if (owners === undefined) {
        owners = [];
        testNameToRetainedOwner.set(testName, owners);
      }
      owners.push(owner);
    }
  }

  OWNER_REFS = [];

  return testNameToRetainedOwner;
}

function getOwnerMetadata(owner) {
  if (owner.mountPoint) {
    return `Engine [mounted at \`/${owner.mountPoint}\`]`;
  }
  return `Application`;
}

function getTestName() {
  const currentTest = QUnit.config.current;
  return `${currentTest.module.name}: ${currentTest.testName}`;
}

function trackOwner(owner) {
  OWNER_REFS.push([new WeakRef(owner), getTestName()]);
}

function applyMonkeyPatchesToCaptureOwners() {
  // eslint-disable-next-line global-require, no-undef
  require('voyager-web/instance-initializers/auto-engine-dependencies');

  // The block below is done to add a class name to the ApplicationInstanceInstance that isn't present in Ember versions less than 4.x.
  // This class name makes it easier to find the owner (needle) in the haystack.
  // This can be removed once the Ember 4.x upgrade is done
  const ApplicationInstance = ApplicationInstanceModule.default;
  ApplicationInstance.proto();
  class VWebApplicationInstance extends ApplicationInstanceModule.default {}
  // eslint-disable-next-line no-import-assign
  ApplicationInstanceModule.default = VWebApplicationInstance;

  Application.proto(); // This is needed to setup the prototype in Ember 3.28
  const originalBuildApplicationInstance = Application.prototype.buildInstance;
  function ApplicationBuildInstanceOverride(options) {
    const owner = originalBuildApplicationInstance.call(this, options);
    trackOwner(owner);
    return owner;
  }

  ApplicationBuildInstanceOverride.isOwnerCaptureMonkeyPatch = true;

  Engine.proto(); // This is needed to setup the prototype in Ember 3.28
  const originalBuildEngineInstance = Engine.prototype.buildInstance;
  function EngineBuildInstanceOverride(options) {
    const owner = originalBuildEngineInstance.call(this, options);
    trackOwner(owner);
    return owner;
  }
  EngineBuildInstanceOverride.isOwnerCaptureMonkeyPatch = true;

  if (!originalBuildApplicationInstance.isOwnerCaptureMonkeyPatch) {
    // This is needed only as long as we have this in Voyager; when it is
    // upstreamed into open source libraries we will not need the monkey-patch.
    // eslint-disable-next-line @linkedin/pemberly/require-read-only-prototypes
    Application.prototype.buildInstance = ApplicationBuildInstanceOverride;
  }

  if (!originalBuildEngineInstance.isOwnerCaptureMonkeyPatch) {
    // This is needed only as long as we have this in Voyager; when it is
    // upstreamed into open source libraries we will not need the monkey-patch.
    // eslint-disable-next-line @linkedin/pemberly/require-read-only-prototypes
    Engine.prototype.buildInstance = EngineBuildInstanceOverride;
  }
}

function ensureTestReleasesTestEnvironment(callback = () => {}) {
  QUnit.on('testStart', () => {
    const currentTest = QUnit.config.current;
    const { finish } = currentTest;

    currentTest.finish = async function () {
      await callback();

      return finish.apply(this, arguments);
    };
  });
}

/**
  After each test is completed, check for owner leaks. This will be the best
  ergonomics (the actual test that leaks will fail), but due to running GC many
  times per test, will be the slowest mechanism.
*/
export function setupPerTestLeakDetection() {
  applyMonkeyPatchesToCaptureOwners();
  ensureTestReleasesTestEnvironment(async function () {
    const currentTest = QUnit.config.current;
    for (const [, owners] of await checkForRetainedOwners()) {
      for (const owner of owners) {
        currentTest.expected++;
        currentTest.assert.pushResult({
          result: false,
          message: `Leaked ${getOwnerMetadata(owner)}`,
        });
      }
    }
  });
}

let hasDonePerModuleLeakDetection = false;

/**
  After each module is completed, check for owner leaks. This will be faster than
  checking for each test, but slower than checking once at the end of all tests.
*/
export function setupPerModuleLeakDetection() {
  applyMonkeyPatchesToCaptureOwners();
  ensureTestReleasesTestEnvironment();

  QUnit.on('suiteEnd', () => {
    if (hasDonePerModuleLeakDetection) return;
    hasDonePerModuleLeakDetection = true;

    QUnit.module('[OWNER LEAK DETECTION]', function () {
      const testBody = async function (assert) {
        assert.expect(0);
        for (const [testName, owner] of await checkForRetainedOwners()) {
          assert.pushResult({
            result: false,
            message: `Leaked ${getOwnerMetadata(owner)} from ${testName}`,
          });
        }
      };
      // Opts the user into the `OWNER LEAK DETECTION` module regardless of filter or module selected.
      testBody.validTest = true;

      QUnit.test('There should be zero leaked Owners', testBody);
    });
  });
}

let hasCheckedOwnerLeaks = false;

/**
  After all tests have been ran, check for any owner leaks. This will be the fastest
  mechanism, but also will be ran the least often (you won't get feedback until all
  tests have completed).
*/
export function setupAfterAllTestsOwnerLeakDetection() {
  applyMonkeyPatchesToCaptureOwners();
  ensureTestReleasesTestEnvironment();

  // Due to details of how QUnit functions (see https://github.com/qunitjs/qunit/pull/1629)
  // we cannot enqueue new tests if we use `runEnd` which is basically what we want (i.e. "when all tests are done run this callback")
  //
  // Instead we use `suiteEnd` and check `QUnit.config.queue` which indicates the number of tests remaining to be ran
  // when `QUnit.config.queue` gets to `0` and `suiteEnd` is running we are finished with all tests **but** `runEnd` / `QUnit.done()` hasn't ran yet so we can still emit new tests
  QUnit.on('suiteEnd', () => {
    if (QUnit.config.queue.length !== 0) {
      return;
    }

    if (hasCheckedOwnerLeaks) return;
    hasCheckedOwnerLeaks = true;

    QUnit.module(`[OWNER LEAK DETECTION]`, function () {
      const testBody = async function (assert) {
        assert.expect(0);

        const leakedOwners = await checkForRetainedOwners();
        for (const [testName, owners] of leakedOwners) {
          for (const owner of owners) {
            assert.pushResult({
              result: false,
              message: `${testName}: Leaked ${getOwnerMetadata(owner)}`,
            });
          }
        }
      };
      // Opts the user into the `OWNER LEAK DETECTION` module regardless of filter or module selected.
      testBody.validTest = true;

      QUnit.test('There should be zero leaked Owners', testBody);
    });
  });
}